package top.frsf.pattern.c_behavioral.b_chainrespon.handler;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import top.frsf.pattern.c_behavioral.b_chainrespon.handler.dto.Person;

/**
 * 责任链 - 抽象类
 *
 * @author FRSF
 * @since 2024/8/20 20:17
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public abstract class LeaveRequestHandler {

    /**
     * 下一个处理者
     */
    private LeaveRequestHandler next;

    /**
     * 是否可以处理请求
     */
    protected abstract boolean canHandle(Person person);

    /**
     * 处理请求逻辑
     */
    protected abstract void handleRequest(Person person);

    /**
     * 添加责任链
     */
    public static LeaveRequestHandler addHandlers(LeaveRequestHandler... handlers) {
        if (handlers.length < 1) {
            throw new RuntimeException("至少需要一个处理器");
        }
        for (int i = 0; i < handlers.length - 1; i++) {
            handlers[i].setNext(handlers[i + 1]);
        }
        return handlers[0];
    }

    /**
     * 纯责任链模式 -- 责任链中只选择第一个能处理的处理者，处理后立即结束责任链
     *           -- 若未找到能处理的处理器，则最后一个处理器进行处理
     */
    public final void processRequest(Person person) {
        if (canHandle(person)) {
            handleRequest(person);
            return;
        }
        if (next != null) {
            next.processRequest(person);
        }else {
            System.out.println("未找到能处理的处理器，使用最后一个责任链进行处理");
            handleRequest(person);
        }
    }

    /**
     * 非纯责任链模式 -- 责任链会持续传递，每个能够处理的处理器都会执行处理逻辑
     *             -- 若未找到能处理的处理器，最终可以不被任何处理器处理
     */
    public final void processRequest2(Person person) {
        if (canHandle(person)) {
            handleRequest(person);
        }
        if (next != null) {
            next.processRequest2(person);
        }
    }

}
